package com.gitee.qdbp.general.trade.api.order.manage.model;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import com.gitee.qdbp.general.trade.enums.FundReceiveType;
import com.gitee.qdbp.general.trade.enums.OrderType;
import com.gitee.qdbp.general.trade.enums.PayChannel;
import com.gitee.qdbp.general.trade.enums.PaySource;
import com.gitee.qdbp.general.trade.enums.PayState;

/**
 * 订单支付查询类
 *
 * @author zhh
 * @version 180625
 */
public class OrderPaymentWhere extends OrderPaymentBean {

    /** 版本序列号 **/
    private static final long serialVersionUID = 1L;

    /** 主键列表 **/
    private List<String> ids;

    /** 主键前模匹配条件 **/
    private String idStarts;

    /** 主键后模匹配条件 **/
    private String idEnds;

    /** 主键模糊查询条件 **/
    private String idLike;

    /** 收款类型(0.平台收款|1.商家收款|2.平台代商家收款)空值/非空值查询 **/
    private Boolean receiveTypeIsNull;

    /** 收款类型(0.平台收款|1.商家收款|2.平台代商家收款)列表 **/
    private List<FundReceiveType> receiveTypes;

    /** 商家租户编号空值/非空值查询 **/
    private Boolean tenantCodeIsNull;

    /** 商家租户编号前模匹配条件 **/
    private String tenantCodeStarts;

    /** 商家租户编号后模匹配条件 **/
    private String tenantCodeEnds;

    /** 商家租户编号模糊查询条件 **/
    private String tenantCodeLike;

    /** 商家账户空值/非空值查询 **/
    private Boolean merchantAccountIsNull;

    /** 商家账户前模匹配条件 **/
    private String merchantAccountStarts;

    /** 商家账户后模匹配条件 **/
    private String merchantAccountEnds;

    /** 商家账户模糊查询条件 **/
    private String merchantAccountLike;

    /** 订单ID空值/非空值查询 **/
    private Boolean orderIdIsNull;

    /** 订单ID前模匹配条件 **/
    private String orderIdStarts;

    /** 订单ID后模匹配条件 **/
    private String orderIdEnds;

    /** 订单ID模糊查询条件 **/
    private String orderIdLike;

    /** 订单类型(0.捐款订单|1.商品订单)空值/非空值查询 **/
    private Boolean orderTypeIsNull;

    /** 订单类型(0.捐款订单|1.商品订单)列表 **/
    private List<OrderType> orderTypes;

    /** 关联业务ID空值/非空值查询 **/
    private Boolean dataIdIsNull;

    /** 关联业务ID前模匹配条件 **/
    private String dataIdStarts;

    /** 关联业务ID后模匹配条件 **/
    private String dataIdEnds;

    /** 关联业务ID模糊查询条件 **/
    private String dataIdLike;

    /** 用户ID空值/非空值查询 **/
    private Boolean userIdIsNull;

    /** 用户ID前模匹配条件 **/
    private String userIdStarts;

    /** 用户ID后模匹配条件 **/
    private String userIdEnds;

    /** 用户ID模糊查询条件 **/
    private String userIdLike;

    /** 订单内容空值/非空值查询 **/
    private Boolean orderContentIsNull;

    /** 订单内容前模匹配条件 **/
    private String orderContentStarts;

    /** 订单内容后模匹配条件 **/
    private String orderContentEnds;

    /** 订单内容模糊查询条件 **/
    private String orderContentLike;

    /** 订单金额(人民币元)空值/非空值查询 **/
    private Boolean orderAmountIsNull;

    /** 最小订单金额(人民币元) **/
    private Double orderAmountMin;

    /** 最大订单金额(人民币元) **/
    private Double orderAmountMax;

    /** 支付金额(人民币元)空值/非空值查询 **/
    private Boolean payAmountIsNull;

    /** 最小支付金额(人民币元) **/
    private Double payAmountMin;

    /** 最大支付金额(人民币元) **/
    private Double payAmountMax;

    /** 支付渠道(0.线下|1.支付宝|2.微信|3.银联)空值/非空值查询 **/
    private Boolean payChannelIsNull;

    /** 支付渠道(0.线下|1.支付宝|2.微信|3.银联)列表 **/
    private List<PayChannel> payChannels;

    /** 支付来源(1.PC网页支付|2.H5网页支付|3.APP支付)空值/非空值查询 **/
    private Boolean paySourceIsNull;

    /** 支付来源(1.PC网页支付|2.H5网页支付|3.APP支付)列表 **/
    private List<PaySource> paySources;

    /** 支付时间空值/非空值查询 **/
    private Boolean payTimeIsNull;

    /** 最小支付时间 **/
    private Date payTimeMin;

    /** 最大支付时间 **/
    private Date payTimeMax;

    /** 最小支付时间 **/
    private Date payTimeMinWithDay;

    /** 最大支付时间 **/
    private Date payTimeMaxWithDay;

    /** 支付单据号空值/非空值查询 **/
    private Boolean voucherCodeIsNull;

    /** 支付单据号前模匹配条件 **/
    private String voucherCodeStarts;

    /** 支付单据号后模匹配条件 **/
    private String voucherCodeEnds;

    /** 支付单据号模糊查询条件 **/
    private String voucherCodeLike;

    /** 交易流水号空值/非空值查询 **/
    private Boolean transactCodeIsNull;

    /** 交易流水号前模匹配条件 **/
    private String transactCodeStarts;

    /** 交易流水号后模匹配条件 **/
    private String transactCodeEnds;

    /** 交易流水号模糊查询条件 **/
    private String transactCodeLike;

    /** 支付状态(1.未支付|2.支付中|3.支付成功|4.支付失败)空值/非空值查询 **/
    private Boolean payStateIsNull;

    /** 支付状态(1.未支付|2.支付中|3.支付成功|4.支付失败)列表 **/
    private List<PayState> payStates;

    /** 选项空值/非空值查询 **/
    private Boolean optionsIsNull;

    /** 最小创建时间 **/
    private Date createTimeMin;

    /** 最大创建时间 **/
    private Date createTimeMax;

    /** 最小创建时间 **/
    private Date createTimeMinWithDay;

    /** 最大创建时间 **/
    private Date createTimeMaxWithDay;

    /** 获取主键列表 **/
    public List<String> getIds() {
        return ids;
    }

    /** 设置主键列表 **/
    public void setIds(List<String> ids) {
        this.ids = ids;
    }

    /** 增加主键 **/
    public void addId(String... ids) {
        if (this.ids == null) {
            this.ids = new ArrayList<>();
        }
        this.ids.addAll(Arrays.asList(ids));
    }

    /** 获取主键前模匹配条件 **/
    public String getIdStarts() {
        return idStarts;
    }

    /** 设置主键前模匹配条件 **/
    public void setIdStarts(String idStarts) {
        this.idStarts = idStarts;
    }

    /** 获取主键后模匹配条件 **/
    public String getIdEnds() {
        return idEnds;
    }

    /** 设置主键后模匹配条件 **/
    public void setIdEnds(String idEnds) {
        this.idEnds = idEnds;
    }

    /** 获取主键模糊查询条件 **/
    public String getIdLike() {
        return idLike;
    }

    /** 设置主键模糊查询条件 **/
    public void setIdLike(String idLike) {
        this.idLike = idLike;
    }

    /** 判断收款类型(0.平台收款|1.商家收款|2.平台代商家收款)是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getReceiveTypeIsNull() {
        return receiveTypeIsNull;
    }

    /**
     * 设置收款类型(0.平台收款|1.商家收款|2.平台代商家收款)空值查询(true:空值查询|false:非空值查询)
     *
     * @param receiveTypeIsNull 收款类型(0.平台收款|1.商家收款|2.平台代商家收款)空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setReceiveTypeIsNull(Boolean receiveTypeIsNull) {
        this.receiveTypeIsNull = receiveTypeIsNull;
    }

    /** 获取收款类型(0.平台收款|1.商家收款|2.平台代商家收款)列表 **/
    public List<FundReceiveType> getReceiveTypes() {
        return receiveTypes;
    }

    /** 设置收款类型(0.平台收款|1.商家收款|2.平台代商家收款)列表 **/
    public void setReceiveTypes(List<FundReceiveType> receiveTypes) {
        this.receiveTypes = receiveTypes;
    }

    /** 增加收款类型(0.平台收款|1.商家收款|2.平台代商家收款) **/
    public void addReceiveType(FundReceiveType... receiveTypes) {
        if (this.receiveTypes == null) {
            this.receiveTypes = new ArrayList<>();
        }
        this.receiveTypes.addAll(Arrays.asList(receiveTypes));
    }

    /** 判断商家租户编号是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getTenantCodeIsNull() {
        return tenantCodeIsNull;
    }

    /**
     * 设置商家租户编号空值查询(true:空值查询|false:非空值查询)
     *
     * @param tenantCodeIsNull 商家租户编号空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setTenantCodeIsNull(Boolean tenantCodeIsNull) {
        this.tenantCodeIsNull = tenantCodeIsNull;
    }

    /** 获取商家租户编号前模匹配条件 **/
    public String getTenantCodeStarts() {
        return tenantCodeStarts;
    }

    /** 设置商家租户编号前模匹配条件 **/
    public void setTenantCodeStarts(String tenantCodeStarts) {
        this.tenantCodeStarts = tenantCodeStarts;
    }

    /** 获取商家租户编号后模匹配条件 **/
    public String getTenantCodeEnds() {
        return tenantCodeEnds;
    }

    /** 设置商家租户编号后模匹配条件 **/
    public void setTenantCodeEnds(String tenantCodeEnds) {
        this.tenantCodeEnds = tenantCodeEnds;
    }

    /** 获取商家租户编号模糊查询条件 **/
    public String getTenantCodeLike() {
        return tenantCodeLike;
    }

    /** 设置商家租户编号模糊查询条件 **/
    public void setTenantCodeLike(String tenantCodeLike) {
        this.tenantCodeLike = tenantCodeLike;
    }

    /** 判断商家账户是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getMerchantAccountIsNull() {
        return merchantAccountIsNull;
    }

    /** 设置商家账户空值查询(true:空值查询|false:非空值查询) **/
    public void setMerchantAccountIsNull(Boolean merchantAccountIsNull) {
        this.merchantAccountIsNull = merchantAccountIsNull;
    }

    /** 获取商家账户前模匹配条件 **/
    public String getMerchantAccountStarts() {
        return merchantAccountStarts;
    }

    /** 设置商家账户前模匹配条件 **/
    public void setMerchantAccountStarts(String merchantAccountStarts) {
        this.merchantAccountStarts = merchantAccountStarts;
    }

    /** 获取商家账户后模匹配条件 **/
    public String getMerchantAccountEnds() {
        return merchantAccountEnds;
    }

    /** 设置商家账户后模匹配条件 **/
    public void setMerchantAccountEnds(String merchantAccountEnds) {
        this.merchantAccountEnds = merchantAccountEnds;
    }

    /** 获取商家账户模糊查询条件 **/
    public String getMerchantAccountLike() {
        return merchantAccountLike;
    }

    /** 设置商家账户模糊查询条件 **/
    public void setMerchantAccountLike(String merchantAccountLike) {
        this.merchantAccountLike = merchantAccountLike;
    }

    /** 判断订单ID是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getOrderIdIsNull() {
        return orderIdIsNull;
    }

    /**
     * 设置订单ID空值查询(true:空值查询|false:非空值查询)
     *
     * @param orderIdIsNull 订单ID空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setOrderIdIsNull(Boolean orderIdIsNull) {
        this.orderIdIsNull = orderIdIsNull;
    }

    /** 获取订单ID前模匹配条件 **/
    public String getOrderIdStarts() {
        return orderIdStarts;
    }

    /** 设置订单ID前模匹配条件 **/
    public void setOrderIdStarts(String orderIdStarts) {
        this.orderIdStarts = orderIdStarts;
    }

    /** 获取订单ID后模匹配条件 **/
    public String getOrderIdEnds() {
        return orderIdEnds;
    }

    /** 设置订单ID后模匹配条件 **/
    public void setOrderIdEnds(String orderIdEnds) {
        this.orderIdEnds = orderIdEnds;
    }

    /** 获取订单ID模糊查询条件 **/
    public String getOrderIdLike() {
        return orderIdLike;
    }

    /** 设置订单ID模糊查询条件 **/
    public void setOrderIdLike(String orderIdLike) {
        this.orderIdLike = orderIdLike;
    }

    /** 判断订单类型(0.捐款订单|1.商品订单)是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getOrderTypeIsNull() {
        return orderTypeIsNull;
    }

    /**
     * 设置订单类型(0.捐款订单|1.商品订单)空值查询(true:空值查询|false:非空值查询)
     *
     * @param orderTypeIsNull 订单类型(0.捐款订单|1.商品订单)空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setOrderTypeIsNull(Boolean orderTypeIsNull) {
        this.orderTypeIsNull = orderTypeIsNull;
    }

    /** 获取订单类型(0.捐款订单|1.商品订单)列表 **/
    public List<OrderType> getOrderTypes() {
        return orderTypes;
    }

    /** 设置订单类型(0.捐款订单|1.商品订单)列表 **/
    public void setOrderTypes(List<OrderType> orderTypes) {
        this.orderTypes = orderTypes;
    }

    /** 增加订单类型(0.捐款订单|1.商品订单) **/
    public void addOrderType(OrderType... orderTypes) {
        if (this.orderTypes == null) {
            this.orderTypes = new ArrayList<>();
        }
        this.orderTypes.addAll(Arrays.asList(orderTypes));
    }

    /** 判断关联业务ID是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getDataIdIsNull() {
        return dataIdIsNull;
    }

    /** 设置关联业务ID空值查询(true:空值查询|false:非空值查询) **/
    public void setDataIdIsNull(Boolean dataIdIsNull) {
        this.dataIdIsNull = dataIdIsNull;
    }

    /** 获取关联业务ID前模匹配条件 **/
    public String getDataIdStarts() {
        return dataIdStarts;
    }

    /** 设置关联业务ID前模匹配条件 **/
    public void setDataIdStarts(String dataIdStarts) {
        this.dataIdStarts = dataIdStarts;
    }

    /** 获取关联业务ID后模匹配条件 **/
    public String getDataIdEnds() {
        return dataIdEnds;
    }

    /** 设置关联业务ID后模匹配条件 **/
    public void setDataIdEnds(String dataIdEnds) {
        this.dataIdEnds = dataIdEnds;
    }

    /** 获取关联业务ID模糊查询条件 **/
    public String getDataIdLike() {
        return dataIdLike;
    }

    /** 设置关联业务ID模糊查询条件 **/
    public void setDataIdLike(String dataIdLike) {
        this.dataIdLike = dataIdLike;
    }

    /** 判断用户ID是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getUserIdIsNull() {
        return userIdIsNull;
    }

    /**
     * 设置用户ID空值查询(true:空值查询|false:非空值查询)
     *
     * @param userIdIsNull 用户ID空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setUserIdIsNull(Boolean userIdIsNull) {
        this.userIdIsNull = userIdIsNull;
    }

    /** 获取用户ID前模匹配条件 **/
    public String getUserIdStarts() {
        return userIdStarts;
    }

    /** 设置用户ID前模匹配条件 **/
    public void setUserIdStarts(String userIdStarts) {
        this.userIdStarts = userIdStarts;
    }

    /** 获取用户ID后模匹配条件 **/
    public String getUserIdEnds() {
        return userIdEnds;
    }

    /** 设置用户ID后模匹配条件 **/
    public void setUserIdEnds(String userIdEnds) {
        this.userIdEnds = userIdEnds;
    }

    /** 获取用户ID模糊查询条件 **/
    public String getUserIdLike() {
        return userIdLike;
    }

    /** 设置用户ID模糊查询条件 **/
    public void setUserIdLike(String userIdLike) {
        this.userIdLike = userIdLike;
    }

    /** 判断订单内容是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getOrderContentIsNull() {
        return orderContentIsNull;
    }

    /**
     * 设置订单内容空值查询(true:空值查询|false:非空值查询)
     *
     * @param orderContentIsNull 订单内容空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setOrderContentIsNull(Boolean orderContentIsNull) {
        this.orderContentIsNull = orderContentIsNull;
    }

    /** 获取订单内容前模匹配条件 **/
    public String getOrderContentStarts() {
        return orderContentStarts;
    }

    /** 设置订单内容前模匹配条件 **/
    public void setOrderContentStarts(String orderContentStarts) {
        this.orderContentStarts = orderContentStarts;
    }

    /** 获取订单内容后模匹配条件 **/
    public String getOrderContentEnds() {
        return orderContentEnds;
    }

    /** 设置订单内容后模匹配条件 **/
    public void setOrderContentEnds(String orderContentEnds) {
        this.orderContentEnds = orderContentEnds;
    }

    /** 获取订单内容模糊查询条件 **/
    public String getOrderContentLike() {
        return orderContentLike;
    }

    /** 设置订单内容模糊查询条件 **/
    public void setOrderContentLike(String orderContentLike) {
        this.orderContentLike = orderContentLike;
    }

    /** 判断订单金额(人民币元)是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getOrderAmountIsNull() {
        return orderAmountIsNull;
    }

    /**
     * 设置订单金额(人民币元)空值查询(true:空值查询|false:非空值查询)
     *
     * @param orderAmountIsNull 订单金额(人民币元)空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setOrderAmountIsNull(Boolean orderAmountIsNull) {
        this.orderAmountIsNull = orderAmountIsNull;
    }

    /** 获取最小订单金额(人民币元) **/
    public Double getOrderAmountMin() {
        return orderAmountMin;
    }

    /** 设置最小订单金额(人民币元) **/
    public void setOrderAmountMin(Double orderAmountMin) {
        this.orderAmountMin = orderAmountMin;
    }

    /** 获取最大订单金额(人民币元) **/
    public Double getOrderAmountMax() {
        return orderAmountMax;
    }

    /** 设置最大订单金额(人民币元) **/
    public void setOrderAmountMax(Double orderAmountMax) {
        this.orderAmountMax = orderAmountMax;
    }

    /** 判断支付金额(人民币元)是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getPayAmountIsNull() {
        return payAmountIsNull;
    }

    /**
     * 设置支付金额(人民币元)空值查询(true:空值查询|false:非空值查询)
     *
     * @param payAmountIsNull 支付金额(人民币元)空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setPayAmountIsNull(Boolean payAmountIsNull) {
        this.payAmountIsNull = payAmountIsNull;
    }

    /** 获取最小支付金额(人民币元) **/
    public Double getPayAmountMin() {
        return payAmountMin;
    }

    /** 设置最小支付金额(人民币元) **/
    public void setPayAmountMin(Double payAmountMin) {
        this.payAmountMin = payAmountMin;
    }

    /** 获取最大支付金额(人民币元) **/
    public Double getPayAmountMax() {
        return payAmountMax;
    }

    /** 设置最大支付金额(人民币元) **/
    public void setPayAmountMax(Double payAmountMax) {
        this.payAmountMax = payAmountMax;
    }

    /** 判断支付渠道(0.线下|1.支付宝|2.微信|3.银联)是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getPayChannelIsNull() {
        return payChannelIsNull;
    }

    /**
     * 设置支付渠道(0.线下|1.支付宝|2.微信|3.银联)空值查询(true:空值查询|false:非空值查询)
     *
     * @param payChannelIsNull 支付渠道(0.线下|1.支付宝|2.微信|3.银联)空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setPayChannelIsNull(Boolean payChannelIsNull) {
        this.payChannelIsNull = payChannelIsNull;
    }

    /** 获取支付渠道(0.线下|1.支付宝|2.微信|3.银联)列表 **/
    public List<PayChannel> getPayChannels() {
        return payChannels;
    }

    /** 设置支付渠道(0.线下|1.支付宝|2.微信|3.银联)列表 **/
    public void setPayChannels(List<PayChannel> payChannels) {
        this.payChannels = payChannels;
    }

    /** 增加支付渠道(0.线下|1.支付宝|2.微信|3.银联) **/
    public void addPayChannel(PayChannel... payChannels) {
        if (this.payChannels == null) {
            this.payChannels = new ArrayList<>();
        }
        this.payChannels.addAll(Arrays.asList(payChannels));
    }

    /** 判断支付来源(1.PC网页支付|2.H5网页支付|3.APP支付)是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getPaySourceIsNull() {
        return paySourceIsNull;
    }

    /**
     * 设置支付来源(1.PC网页支付|2.H5网页支付|3.APP支付)空值查询(true:空值查询|false:非空值查询)
     *
     * @param paySourceIsNull 支付来源(1.PC网页支付|2.H5网页支付|3.APP支付)空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setPaySourceIsNull(Boolean paySourceIsNull) {
        this.paySourceIsNull = paySourceIsNull;
    }

    /** 获取支付来源(1.PC网页支付|2.H5网页支付|3.APP支付)列表 **/
    public List<PaySource> getPaySources() {
        return paySources;
    }

    /** 设置支付来源(1.PC网页支付|2.H5网页支付|3.APP支付)列表 **/
    public void setPaySources(List<PaySource> paySources) {
        this.paySources = paySources;
    }

    /** 增加支付来源(1.PC网页支付|2.H5网页支付|3.APP支付) **/
    public void addPaySource(PaySource... paySources) {
        if (this.paySources == null) {
            this.paySources = new ArrayList<>();
        }
        this.paySources.addAll(Arrays.asList(paySources));
    }

    /** 判断支付时间是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getPayTimeIsNull() {
        return payTimeIsNull;
    }

    /**
     * 设置支付时间空值查询(true:空值查询|false:非空值查询)
     *
     * @param payTimeIsNull 支付时间空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setPayTimeIsNull(Boolean payTimeIsNull) {
        this.payTimeIsNull = payTimeIsNull;
    }

    /** 获取最小支付时间 **/
    public Date getPayTimeMin() {
        return payTimeMin;
    }

    /** 设置最小支付时间 **/
    public void setPayTimeMin(Date payTimeMin) {
        this.payTimeMin = payTimeMin;
    }

    /** 获取最大支付时间 **/
    public Date getPayTimeMax() {
        return payTimeMax;
    }

    /** 设置最大支付时间 **/
    public void setPayTimeMax(Date payTimeMax) {
        this.payTimeMax = payTimeMax;
    }

    /** 获取最小支付时间 **/
    public Date getPayTimeMinWithDay() {
        return payTimeMinWithDay;
    }

    /** 设置最小支付时间 **/
    public void setPayTimeMinWithDay(Date payTimeMinWithDay) {
        this.payTimeMinWithDay = payTimeMinWithDay;
    }

    /** 获取最大支付时间 **/
    public Date getPayTimeMaxWithDay() {
        return payTimeMaxWithDay;
    }

    /** 设置最大支付时间 **/
    public void setPayTimeMaxWithDay(Date payTimeMaxWithDay) {
        this.payTimeMaxWithDay = payTimeMaxWithDay;
    }

    /** 判断支付单据号是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getVoucherCodeIsNull() {
        return voucherCodeIsNull;
    }

    /** 设置支付单据号空值查询(true:空值查询|false:非空值查询) **/
    public void setVoucherCodeIsNull(Boolean voucherCodeIsNull) {
        this.voucherCodeIsNull = voucherCodeIsNull;
    }

    /** 获取支付单据号前模匹配条件 **/
    public String getVoucherCodeStarts() {
        return voucherCodeStarts;
    }

    /** 设置支付单据号前模匹配条件 **/
    public void setVoucherCodeStarts(String voucherCodeStarts) {
        this.voucherCodeStarts = voucherCodeStarts;
    }

    /** 获取支付单据号后模匹配条件 **/
    public String getVoucherCodeEnds() {
        return voucherCodeEnds;
    }

    /** 设置支付单据号后模匹配条件 **/
    public void setVoucherCodeEnds(String voucherCodeEnds) {
        this.voucherCodeEnds = voucherCodeEnds;
    }

    /** 获取支付单据号模糊查询条件 **/
    public String getVoucherCodeLike() {
        return voucherCodeLike;
    }

    /** 设置支付单据号模糊查询条件 **/
    public void setVoucherCodeLike(String voucherCodeLike) {
        this.voucherCodeLike = voucherCodeLike;
    }

    /** 判断交易流水号是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getTransactCodeIsNull() {
        return transactCodeIsNull;
    }

    /** 设置交易流水号空值查询(true:空值查询|false:非空值查询) **/
    public void setTransactCodeIsNull(Boolean transactCodeIsNull) {
        this.transactCodeIsNull = transactCodeIsNull;
    }

    /** 获取交易流水号前模匹配条件 **/
    public String getTransactCodeStarts() {
        return transactCodeStarts;
    }

    /** 设置交易流水号前模匹配条件 **/
    public void setTransactCodeStarts(String transactCodeStarts) {
        this.transactCodeStarts = transactCodeStarts;
    }

    /** 获取交易流水号后模匹配条件 **/
    public String getTransactCodeEnds() {
        return transactCodeEnds;
    }

    /** 设置交易流水号后模匹配条件 **/
    public void setTransactCodeEnds(String transactCodeEnds) {
        this.transactCodeEnds = transactCodeEnds;
    }

    /** 获取交易流水号模糊查询条件 **/
    public String getTransactCodeLike() {
        return transactCodeLike;
    }

    /** 设置交易流水号模糊查询条件 **/
    public void setTransactCodeLike(String transactCodeLike) {
        this.transactCodeLike = transactCodeLike;
    }

    /** 判断支付状态(1.未支付|2.支付中|3.支付成功|4.支付失败)是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getPayStateIsNull() {
        return payStateIsNull;
    }

    /**
     * 设置支付状态(1.未支付|2.支付中|3.支付成功|4.支付失败)空值查询(true:空值查询|false:非空值查询)
     *
     * @param payStateIsNull 支付状态(1.未支付|2.支付中|3.支付成功|4.支付失败)空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setPayStateIsNull(Boolean payStateIsNull) {
        this.payStateIsNull = payStateIsNull;
    }

    /** 获取支付状态(1.未支付|2.支付中|3.支付成功|4.支付失败)列表 **/
    public List<PayState> getPayStates() {
        return payStates;
    }

    /** 设置支付状态(1.未支付|2.支付中|3.支付成功|4.支付失败)列表 **/
    public void setPayStates(List<PayState> payStates) {
        this.payStates = payStates;
    }

    /** 增加支付状态(1.未支付|2.支付中|3.支付成功|4.支付失败) **/
    public void addPayState(PayState... payStates) {
        if (this.payStates == null) {
            this.payStates = new ArrayList<>();
        }
        this.payStates.addAll(Arrays.asList(payStates));
    }

    /** 判断选项是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getOptionsIsNull() {
        return optionsIsNull;
    }

    /** 设置选项空值查询(true:空值查询|false:非空值查询) **/
    public void setOptionsIsNull(Boolean optionsIsNull) {
        this.optionsIsNull = optionsIsNull;
    }

    /** 获取最小创建时间 **/
    public Date getCreateTimeMin() {
        return createTimeMin;
    }

    /** 设置最小创建时间 **/
    public void setCreateTimeMin(Date createTimeMin) {
        this.createTimeMin = createTimeMin;
    }

    /** 获取最大创建时间 **/
    public Date getCreateTimeMax() {
        return createTimeMax;
    }

    /** 设置最大创建时间 **/
    public void setCreateTimeMax(Date createTimeMax) {
        this.createTimeMax = createTimeMax;
    }

    /** 获取最小创建时间 **/
    public Date getCreateTimeMinWithDay() {
        return createTimeMinWithDay;
    }

    /** 设置最小创建时间 **/
    public void setCreateTimeMinWithDay(Date createTimeMinWithDay) {
        this.createTimeMinWithDay = createTimeMinWithDay;
    }

    /** 获取最大创建时间 **/
    public Date getCreateTimeMaxWithDay() {
        return createTimeMaxWithDay;
    }

    /** 设置最大创建时间 **/
    public void setCreateTimeMaxWithDay(Date createTimeMaxWithDay) {
        this.createTimeMaxWithDay = createTimeMaxWithDay;
    }

}